int* path;
int pathTop;
int** ans;
int ansTop;
int* length; // step 0# 记录每个子序列的长度

// step 1# 将当前 path 中的内容复制到 ans 中
void copy() {
    int* tempPath = (int*)malloc(sizeof(int) * pathTop);
    memcpy(tempPath, path, pathTop * sizeof(int));
    length[ansTop] = pathTop;
    ans[ansTop++] = tempPath;
}

// step 2# 判断 uset 中是否存在值为 key 的元素（用于同一树层去重）
int find(int* uset, int usetSize, int key) {
    for(int i = 0; i < usetSize; i++) {
        if(uset[i] == key)
            return 1;
    }
    return 0;
}

// step 3# 回溯函数，用于查找所有递增子序列（长度 ≥ 2）
void backTracking(int* nums, int numsSize, int startIndex) {
    // step 3.1# 如果 path 中元素数目 ≥ 2，收集为一个合法结果
    if(pathTop > 1) {
        copy();
    }

    // step 3.2# 用于当前树层去重的哈希集合（模拟）
    int* uset = (int*)malloc(sizeof(int) * numsSize);
    int usetTop = 0;

    for(int i = startIndex; i < numsSize; i++) {
        // note 1### 这里去重是用哈希表来去重，T9 中是用 used[]来去重 
        // step 3.3# 剪枝条件：
        // a. 当前元素小于 path 最后一个元素 → 不是递增序列
        // b. 当前元素已在本树层中出现过 → 去重
        if((pathTop > 0 && nums[i] < path[pathTop - 1]) || find(uset, usetTop, nums[i]))
            continue;

        // step 3.4# 标记当前树层已经使用过 nums[i]
        uset[usetTop++] = nums[i];

        // step 3.5# 选中当前元素，进入下一层递归
        path[pathTop++] = nums[i];
        backTracking(nums, numsSize, i + 1);

        // step 3.6# 回溯：撤销当前选择
        pathTop--;
    }

    // step 3.7# 释放当前层 uset（注意内存泄露风险）
    free(uset);
}

// step 4# 主函数入口，初始化变量，启动回溯
int** findSubsequences(int* nums, int numsSize, int* returnSize, int** returnColumnSizes) {
    // step 4.1# 初始化辅助结构
    path = (int*)malloc(sizeof(int) * numsSize);
    ans = (int**)malloc(sizeof(int*) * 33000);
    length = (int*)malloc(sizeof(int) * 33000);
    pathTop = ansTop = 0;

    // step 4.2# 启动回溯搜索
    backTracking(nums, numsSize, 0);

    // step 4.3# 设置返回值
    *returnSize = ansTop;
    *returnColumnSizes = (int*)malloc(sizeof(int) * ansTop);
    for(int i = 0; i < ansTop; i++) {
        (*returnColumnSizes)[i] = length[i];
    }

    // step 4.4# 返回所有合法子序列
    return ans;
}
